// 视频动效模块 - 增强版
function initLoveVideoEffect(canvas, videoUrl) {
    // 获取2D渲染上下文
    const ctx = canvas.getContext('2d');
    
    // 存储视频元素和动画帧ID
    let video = null;
    let animationId = null;
    
    // 用于检测视频是否真正卡住的时间戳
    let lastVideoTime = null;
    let lastCheckTime = Date.now();
    let consecutiveStuckFrames = 0;
    
    // 优化视频元素管理 - 确保切换回来时能正确重新初始化
    // 首先清除之前可能存在的视频元素
    if (window.loveVideoElement) {
        // 移除之前的resize监听
        if (window.loveVideoResizeHandler) {
            window.removeEventListener('resize', window.loveVideoResizeHandler);
            window.loveVideoResizeHandler = null;
        }
        
        // 清理视频元素
        window.loveVideoElement.pause();
        window.loveVideoElement.src = '';
        window.loveVideoElement.remove();
        window.loveVideoElement = null;
    }
    
    // 清除之前的动画
    if (animationId) {
        cancelAnimationFrame(animationId);
        animationId = null;
    }
    
    // 当前透明度（用于淡入淡出效果）
    let opacity = 0;
    let transitionActive = false;
    
    // 设置默认深色背景
    function setDefaultBackground() {
        // 清除画布
        ctx.clearRect(0, 0, canvas.width, canvas.height);
        
        // 设置淡入的深色背景，使用半透明深蓝色以避免闪黑
        ctx.fillStyle = 'rgba(26, 32, 44, 0.95)'; // 半透明深蓝色
        ctx.fillRect(0, 0, canvas.width, canvas.height);
        
        // 移除心形装饰
        
        // 移除渐变边框，不再绘制
        
        // 显示提示文字
        ctx.fillStyle = `rgba(255, 255, 255, ${opacity * 0.8})`; // 透明度随过渡效果变化
        ctx.font = 'bold 22px Arial, sans-serif';
        ctx.textAlign = 'center';
        
        // 添加文字阴影增强可读性
        ctx.shadowColor = 'rgba(0, 0, 0, 0.7)';
        ctx.shadowBlur = 5;
        ctx.shadowOffsetX = 0;
        ctx.shadowOffsetY = 2;
        
        ctx.fillText('主题视频', canvas.width / 2, canvas.height / 2);
        
        ctx.fillStyle = `rgba(255, 255, 255, ${opacity * 0.7})`;
        ctx.font = '14px Arial, sans-serif';
        ctx.fillText(videoUrl ? '正在加载视频...' : '请在配置中上传主题视频', canvas.width / 2, canvas.height / 2 + 30);
        
        // 重置阴影设置
        ctx.shadowColor = 'transparent';
        ctx.shadowBlur = 0;
        ctx.shadowOffsetX = 0;
        ctx.shadowOffsetY = 0;
    }
    
    // 渐变边框函数已移除，不再绘制边框
    
    // 心形装饰函数已移除
    
    // 初始设置默认背景
    setDefaultBackground();
    
    // 检查视频URL的有效性
    if (!videoUrl || typeof videoUrl !== 'string' || videoUrl.trim() === '') {
        console.warn('No valid video URL provided for love-video effect');
        return;
    }
    
    // 规范化URL，确保路径正确
    let normalizedUrl = videoUrl.trim();
    // 如果是相对路径，确保它以斜杠开头
    if (!normalizedUrl.startsWith('http') && !normalizedUrl.startsWith('/')) {
        normalizedUrl = '/' + normalizedUrl;
    }
    
    // 检查视频格式兼容性
    function isVideoFormatSupported(url) {
        const supportedFormats = ['.mp4', '.webm', '.ogg'];
        const lowercaseUrl = url.toLowerCase();
        return supportedFormats.some(format => lowercaseUrl.endsWith(format));
    }
    
    // 检查视频格式
    if (!isVideoFormatSupported(normalizedUrl)) {
        console.warn('Unsupported video format, trying anyway:', normalizedUrl);
        // 这里只是警告，仍然尝试加载，因为某些浏览器可能支持其他格式
    }
    
    // 尝试获取视频文件信息（异步）
    function checkVideoFileExistence() {
        return new Promise((resolve, reject) => {
            const xhr = new XMLHttpRequest();
            xhr.open('HEAD', normalizedUrl);
            xhr.timeout = 5000; // 5秒超时
            
            xhr.onload = function() {
                if (xhr.status >= 200 && xhr.status < 300) {
                    const contentType = xhr.getResponseHeader('Content-Type');
                    resolve({
                        exists: true,
                        contentType: contentType || 'unknown',
                        isVideo: contentType && contentType.startsWith('video/')
                    });
                } else {
                    resolve({ exists: false });
                }
            };
            
            xhr.onerror = xhr.ontimeout = () => resolve({ exists: false });
            xhr.send();
        });
    }
    
    try {
        // 创建视频元素
        video = document.createElement('video');
        // 设置属性前先添加到文档中
        document.body.appendChild(video);
        
        // 设置视频属性
        video.style.display = 'none'; // 隐藏视频元素
        video.loop = true; // 循环播放
        video.muted = true; // 确保视频静音播放
        video.playsInline = true; // 在移动设备上内联播放（iOS）
        video.preload = 'metadata'; // 预加载视频元数据，减少初始加载时间
        
        // 存储视频元素到window对象，方便后续管理
        window.loveVideoElement = video;
        
        // 先检查视频文件是否存在和类型
        checkVideoFileExistence().then(fileInfo => {
            if (!fileInfo.exists) {
                console.error('Video file not found:', normalizedUrl);
                displayErrorAndCleanup('视频文件未找到，请检查文件路径');
                return;
            }
            
            if (!fileInfo.isVideo) {
                console.error('File is not a valid video type:', fileInfo.contentType);
                displayErrorAndCleanup(`文件类型错误 (${fileInfo.contentType})，请上传有效的视频文件`);
                return;
            }
            
            console.log('Video file exists and is a valid video type:', fileInfo.contentType);
            
            // 尝试加载视频，使用更可靠的方式
            try {
                // 使用canPlayType方法检查浏览器兼容性
                if (video) {
                    const canPlay = video.canPlayType('video/mp4');
                    if (canPlay === '' && normalizedUrl.toLowerCase().endsWith('.mp4')) {
                        console.warn('Browser may not support MP4 format');
                    }
                } else {
                    console.error('Video element is null, cannot check format compatibility');
                    displayErrorAndCleanup('视频元素初始化失败');
                    return;
                }
                
                // 设置src属性
                video.src = normalizedUrl;
                
                // 立即调用load，不再延迟
                try {
                    video.load();
                    console.log('Video loading initiated:', normalizedUrl);
                } catch (loadError) {
                    console.error('Failed to load video:', loadError);
                    // 尝试备选加载方式
                    try {
                        console.log('尝试备选加载方式...');
                        video.src = '';
                        video.src = normalizedUrl;
                        // 不调用load，让浏览器自行处理
                    } catch (retryError) {
                        console.error('备选加载方式也失败:', retryError);
                        displayErrorAndCleanup('视频加载失败，可能是格式不支持或文件损坏');
                    }
                }
            } catch (loadError) {
                console.error('Failed to set video source:', loadError);
                displayErrorAndCleanup('设置视频源失败');
            }
        });
        
        // 辅助函数：显示错误并清理资源
        function displayErrorAndCleanup(errorMessage) {
            setDefaultBackground();
            ctx.fillStyle = 'rgba(255, 99, 71, 0.9)';
            ctx.font = '16px Arial, sans-serif';
            ctx.fillText(errorMessage, canvas.width / 2, canvas.height / 2 + 60);
            ctx.fillText(`URL: ${normalizedUrl.substring(0, 30)}${normalizedUrl.length > 30 ? '...' : ''}`, canvas.width / 2, canvas.height / 2 + 85);
            
            setTimeout(() => {
                cleanup();
            }, 3000);
        }
        
        // 视频可以播放时开始绘制
        if (video) {
            video.oncanplay = function() {
                console.log('Video ready to play');
                // 即使在自动播放失败的情况下，如果视频已经准备好，也尝试开始播放
                if (video && video.readyState >= 2 && (video.paused || video.ended)) {
                try {
                    video.play().then(() => {
                        console.log('Started playback from oncanplay event');
                        startFadeIn();
                    }).catch(e => console.log('Play attempt from oncanplay failed:', e));
                } catch (e) {
                    console.log('Error in oncanplay handler:', e);
                }
            }
        };
        }
        
        // 添加视频加载开始事件，确保过渡平滑
        video.onloadstart = function() {
            console.log('Video loading started');
            // 确保视频始终静音
            if (video) {
                video.muted = true;
            }
            // 保持半透明背景直到视频准备就绪
        };
        
        // 添加视频可以流畅播放事件的额外处理，优化过渡
        video.oncanplaythrough = function() {
            console.log('Video can play through');
            // 确保视频始终静音
            if (video) {
                video.muted = true;
            }
            // 视频已足够加载，可以流畅播放，开始淡入
            if (!transitionActive && video && video.readyState >= 2) {
                startFadeIn();
            }
        };
        
        // 视频加载错误处理 - 增强版
        video.onerror = function(e) {
            // 使用事件对象的target获取视频元素，避免依赖外部video变量
            const videoElement = e.target || video;
            
            // 收集详细的错误信息
            const errorDetails = {
                videoUrl: normalizedUrl,
                errorCode: 'Unknown',
                errorMessage: 'Unknown error',
                networkState: 'Unknown',
                readyState: 'Unknown',
                eventType: e.type || 'error',
                timestamp: new Date().toISOString()
            };
            
            // 安全地检查视频元素及其属性
            if (videoElement) {
                try {
                    errorDetails.networkState = videoElement.networkState;
                    errorDetails.readyState = videoElement.readyState;
                    
                    if (videoElement.error) {
                        errorDetails.errorCode = videoElement.error.code;
                        errorDetails.errorMessage = getVideoErrorDescription(videoElement.error.code);
                    }
                } catch (err) {
                    console.warn('Error accessing video properties:', err);
                }
            }
            
            // 提供更详细的错误日志
            console.error('Error loading love video:', errorDetails);
            
            // 显示错误信息
            setDefaultBackground();
            ctx.fillStyle = 'rgba(255, 99, 71, 0.9)';
            ctx.font = '16px Arial, sans-serif';
            
            // 根据错误类型显示更具体的错误信息和建议
            let errorText = '视频加载失败，请检查URL或文件格式';
            let suggestion = '';
            
            if (videoElement && videoElement.error) {
                errorText = getVideoErrorDescription(videoElement.error.code);
                
                // 添加具体的解决方案建议
                switch (videoElement.error.code) {
                    case 4: // 视频格式不支持或损坏
                        suggestion = '视频格式不支持或已损坏';
                        // 增强的备选视频加载方案
                        try {
                            console.log('尝试使用备选视频加载方案...');
                            // 1. 尝试使用不同的加载方式
                            if (videoElement) {
                                // 重置视频元素
                                videoElement.pause();
                                videoElement.src = '';
                                videoElement.muted = true; // 确保重新加载时也是静音的
                                
                                // 重新设置src并尝试直接加载
                                videoElement.src = normalizedUrl;
                                
                                // 尝试绕过预加载，直接播放
                                setTimeout(() => {
                                    try {
                                        videoElement.play().catch(e => console.log('备选播放方案失败:', e));
                                    } catch (innerE) {
                                        console.log('直接播放尝试失败:', innerE);
                                    }
                                }, 300);
                            }
                        } catch (e) {
                            console.log('备选方案执行失败:', e);
                        }
                        break;
                    case 2: // 网络错误
                        suggestion = '请检查网络连接并重试';
                        break;
                    case 3: // 解码错误
                        suggestion = '视频文件可能已损坏，请尝试重新编码';
                        break;
                }
            }
            
            ctx.fillText(errorText, canvas.width / 2, canvas.height / 2 + 60);
            if (suggestion) {
                ctx.fillText(suggestion, canvas.width / 2, canvas.height / 2 + 85);
            }
            ctx.fillText(`URL: ${normalizedUrl.substring(0, 30)}${normalizedUrl.length > 30 ? '...' : ''}`, canvas.width / 2, canvas.height / 2 + 105);
            
            // 添加重试按钮
            const retryBtn = {
                x: canvas.width / 2 - 50,
                y: canvas.height / 2 + 130,
                width: 100,
                height: 30,
                text: '重试加载'
            };
            
            // 绘制重试按钮
            ctx.fillStyle = 'rgba(70, 130, 180, 0.8)';
            ctx.fillRect(retryBtn.x, retryBtn.y, retryBtn.width, retryBtn.height);
            ctx.strokeStyle = 'rgba(255, 255, 255, 0.8)';
            ctx.lineWidth = 1;
            ctx.strokeRect(retryBtn.x, retryBtn.y, retryBtn.width, retryBtn.height);
            
            ctx.fillStyle = 'white';
            ctx.font = '14px Arial, sans-serif';
            ctx.textAlign = 'center';
            ctx.fillText(retryBtn.text, canvas.width / 2, canvas.height / 2 + 150);
            
            // 添加点击重试功能
            function handleRetry(event) {
                const rect = canvas.getBoundingClientRect();
                const x = event.clientX - rect.left;
                const y = event.clientY - rect.top;
                
                if (x >= retryBtn.x && x <= retryBtn.x + retryBtn.width && 
                    y >= retryBtn.y && y <= retryBtn.y + retryBtn.height) {
                    console.log('Retrying video load...');
                    
                    // 移除事件监听
                    canvas.removeEventListener('click', handleRetry);
                    canvas.removeEventListener('touchstart', handleRetry);
                    
                    // 清理并重新初始化
                    cleanup();
                    initLoveVideoEffect(canvas, videoUrl);
                }
            }
            
            canvas.addEventListener('click', handleRetry);
            canvas.addEventListener('touchstart', handleRetry);
            
            // 延迟清理资源，让用户能看到错误信息
            setTimeout(() => {
                // 仅在用户没有点击重试的情况下清理
                if (window.loveVideoElement === video) {
                    cleanup();
                }
            }, 5000); // 延长显示时间到5秒
        };
        
        // 获取视频错误的可读描述
        function getVideoErrorDescription(code) {
            switch(code) {
                case 1: return '用户中止了获取过程';
                case 2: return '获取过程中出现网络错误';
                case 3: return '解码过程中出现错误';
                case 4: return '视频格式不支持或损坏';
                default: return '视频加载失败，请检查URL或文件格式';
            }
        }
        
        // 添加视频元数据加载事件
        video.onloadedmetadata = function() {
            // 添加空值检查，防止video对象已经变为null的情况
            if (!video) {
                console.warn('Video element is null in onloadedmetadata');
                return;
            }
            
            try {
                console.log('Video metadata loaded:', {
                    width: video.videoWidth,
                    height: video.videoHeight,
                    duration: video.duration
                });
                // 元数据加载成功，尝试播放
                if (video.readyState >= 1) {
                    console.log('Video metadata available, trying to play');
                }
            } catch (e) {
                console.error('Error in onloadedmetadata:', e);
            }
        };
        
        // 添加视频加载进度事件
        video.onprogress = function() {
            // 添加空值检查，防止video对象已经变为null的情况
            if (!video) {
                console.warn('Video element is null in onprogress');
                return;
            }
            
            try {
                if (video.buffered && video.buffered.length > 0) {
                    const bufferedEnd = video.buffered.end(video.buffered.length - 1);
                    const duration = video.duration;
                    if (duration > 0) {
                        const loadPercentage = (bufferedEnd / duration) * 100;
                        console.log(`Video loading progress: ${loadPercentage.toFixed(1)}%`);
                    }
                }
            } catch (e) {
                console.error('Error in onprogress:', e);
            }
        };
        
        // 视频播放错误处理
        video.onstalled = function() {
            // 添加空值检查
            if (!video) {
                console.warn('Video element is null in onstalled');
                return;
            }
            
            console.warn('Video playback stalled');
            // 更积极的恢复策略
            try {
                // 立即尝试恢复播放
                if (video.paused) {
                    video.play().catch(e => console.error('Failed to resume video immediately:', e));
                }
            } catch (e) {
                console.error('Error in immediate stall recovery:', e);
            }
            
            // 延迟后再次尝试恢复，确保恢复成功
            setTimeout(() => {
                // 在超时回调中再次检查video对象是否存在
                if (!video) {
                    console.warn('Video element became null during stall recovery');
                    return;
                }
                
                try {
                    // 检查视频是否真的卡住（.currentTime在5秒内没有变化）
                    if (lastVideoTime !== null && video.currentTime === lastVideoTime) {
                        console.warn('Video is truly stuck, attempting to restart playback');
                        // 尝试快进一小段，然后播放
                        video.currentTime = Math.min(video.currentTime + 0.1, video.duration || video.currentTime + 0.1);
                    }
                    
                    if (video.paused) {
                        video.play().catch(e => {
                            console.error('Failed to resume video after delay:', e);
                            // 更激进的恢复措施
                            try {
                                video.load();
                                setTimeout(() => video.play().catch(e => console.error('Final recovery attempt failed:', e)), 300);
                            } catch (e) {
                                console.error('Error in aggressive recovery:', e);
                            }
                        });
                    }
                } catch (e) {
                    console.error('Error in delayed stall recovery:', e);
                }
            }, 1000);
        };
        
        // 开始淡入效果
        function startFadeIn() {
            // 确保只有在必要时才开始淡入
            if (transitionActive || !video || video.readyState < 2) {
                console.log('Fade in skipped - already active, no video, or video not ready');
                return;
            }
            
            transitionActive = true;
            opacity = 0;
            let fadeStartTime = Date.now();
            
            function animateFade() {
                // 使用时间控制的淡入，更平滑
                const elapsedTime = Date.now() - fadeStartTime;
                const fadeDuration = 1500; // 增加淡入时间到1.5秒，使过渡更平滑
                opacity = Math.min(elapsedTime / fadeDuration, 1);
                
                if (video && video.readyState >= 2) {
                    // 即使在淡入过程中，也要确保视频始终静音
                    if (video.muted === false) {
                        video.muted = true;
                    }
                    drawVideo();
                } else {
                    setDefaultBackground();
                }
                
                if (opacity < 1) {
                    // 确保每次动画帧请求都更新animationId
                    const newAnimationId = requestAnimationFrame(animateFade);
                    animationId = newAnimationId;
                } else {
                    opacity = 1;
                    transitionActive = false;
                    console.log('Fade in complete');
                }
            }
            
            // 保存动画ID
            animationId = requestAnimationFrame(animateFade);
    }
    
    // 视频绘制函数 - 增强版
    function drawVideo() {
        if (!video) {
            console.warn('Video element is null');
            setDefaultBackground();
            // 尝试重新初始化视频
            setTimeout(() => {
                try {
                    if (window.loveVideoEffect) {
                        window.loveVideoEffect.cleanup();
                    }
                    window.loveVideoEffect = initLoveVideoEffect(canvas, videoUrl);
                } catch (e) {
                    console.error('Failed to reinitialize video:', e);
                }
            }, 2000);
            return;
        }
        
        if (video.ended) {
            console.warn('Video ended, restarting...');
            try {
                video.currentTime = 0;
                video.play().catch(e => console.error('Failed to restart ended video:', e));
            } catch (e) {
                console.error('Error restarting ended video:', e);
            }
            setDefaultBackground();
            return;
        }
        
        // 定期检查视频播放状态，防止视频卡住
        const currentTime = Date.now();
        if (currentTime - lastCheckTime > 2000) { // 每2秒检查一次
            lastCheckTime = currentTime;
            
            try {
                if (video.readyState >= 2 && !video.paused) {
                    // 检查视频是否真正在播放（时间是否前进）
                    if (lastVideoTime !== null && video.currentTime === lastVideoTime) {
                        consecutiveStuckFrames++;
                        console.warn(`Video appears stuck at ${video.currentTime}, consecutive stuck frames: ${consecutiveStuckFrames}`);
                        
                        // 如果连续多次检测到视频卡住，尝试恢复
                        if (consecutiveStuckFrames >= 3) {
                            console.warn('Video appears to be stuck, attempting recovery...');
                            // 尝试快进一小段
                            video.currentTime = Math.min(video.currentTime + 0.1, video.duration || video.currentTime + 0.1);
                            // 重新开始播放
                            video.play().catch(e => console.error('Recovery play attempt failed:', e));
                            consecutiveStuckFrames = 0;
                        }
                    } else {
                        // 视频正常播放，重置计数器
                        consecutiveStuckFrames = 0;
                    }
                    lastVideoTime = video.currentTime;
                }
            } catch (e) {
                console.error('Error checking video playback status:', e);
            }
        }
        
        // 清除画布
        ctx.clearRect(0, 0, canvas.width, canvas.height);
        
        try {
            // 计算视频的缩放比例以适应画布（保持纵横比）
            const videoRatio = video.videoWidth / video.videoHeight;
            const canvasRatio = canvas.width / canvas.height;
            let drawWidth, drawHeight, offsetX, offsetY;
            
            // 改进的视频缩放逻辑，确保在各种屏幕尺寸上都能正确适配
            const scaleFactor = 1.2; // 略微增加缩放因子以确保完全填充画布
            
            // 计算视频的缩放比例
            let scale;
            if (videoRatio > canvasRatio) {
                // 视频更宽，以宽度为基准缩放
                scale = (canvas.width / video.videoWidth) * scaleFactor;
            } else {
                // 视频更高，以高度为基准缩放
                scale = (canvas.height / video.videoHeight) * scaleFactor;
            }
            
            // 计算绘制尺寸
            drawWidth = video.videoWidth * scale;
            drawHeight = video.videoHeight * scale;
            
            // 计算偏移量，使视频居中
            offsetX = (canvas.width - drawWidth) / 2;
            offsetY = (canvas.height - drawHeight) / 2;
            
            // 保存当前状态
            ctx.save();
            
            // 设置全局透明度，用于过渡效果
            ctx.globalAlpha = opacity;
            
            // 绘制视频帧
            ctx.drawImage(video, offsetX, offsetY, drawWidth, drawHeight);
            
            // 移除色彩覆盖层，保持视频原始画质
            
            // 恢复状态
            ctx.restore();
            
            // 无论过渡效果是否激活，都继续下一帧以确保视频持续播放
            // 这可以防止动画循环中断导致的视频卡住问题
            animationId = requestAnimationFrame(drawVideo);
        } catch (e) {
            console.error('Error drawing video frame:', e);
            // 不再直接清理，而是尝试恢复绘制
            setDefaultBackground();
            // 延迟重新启动绘制，而不是完全停止
            setTimeout(() => {
                if (video && !video.paused) {
                    drawVideo();
                }
            }, 100);
        }
    }
        
        // 增强版视频播放尝试，添加更多错误处理和重试机制
        function tryToPlayVideo() {
            // 确保视频对象存在
            if (!video) {
                console.error('Video element is null, cannot play');
                displayErrorAndCleanup('视频元素初始化失败');
                return;
            }
            
            // 确保视频静音
            video.muted = true;
            // 尝试播放视频
            video.play().then(() => {
                console.log('Video playing successfully');
                // 开始淡入效果
                startFadeIn();
            }).catch(error => {
                console.warn('Auto-play prevented or failed:', error);
                
                // 更强大的自动恢复机制
                let retryCount = 0;
                const maxRetries = 3;
                
                function attemptRecovery() {
                    retryCount++;
                    console.log(`Attempting recovery (${retryCount}/${maxRetries})...`);
                    
                    if (video) {
                        try {
                            // 重置视频元素
                            video.pause();
                            video.src = '';
                            video.src = normalizedUrl;
                            video.muted = true; // 确保重新加载时也是静音的
                            video.load();
                            
                            // 尝试播放
                            video.play().then(() => {
                                console.log('Recovery successful after retry');
                                startFadeIn();
                            }).catch(e => {
                                console.log(`Recovery attempt ${retryCount} failed:`, e);
                                // 如果还有重试机会，继续尝试
                                if (retryCount < maxRetries) {
                                    setTimeout(attemptRecovery, 1000 * retryCount); // 递增延迟
                                }
                            });
                        } catch (e) {
                            console.log(`Recovery failed:`, e);
                            if (retryCount < maxRetries) {
                                setTimeout(attemptRecovery, 1000 * retryCount);
                            }
                        }
                    }
                }
                
                // 开始恢复尝试
                setTimeout(attemptRecovery, 500);
            });
        }
        
        // 尝试播放视频
        tryToPlayVideo();
        
    } catch (error) {
        console.error('Error initializing love video effect:', error);
        setDefaultBackground();
        cleanup();
    }
    
    // 清理资源的函数 - 增强版，添加完整的事件监听器移除
    function cleanup() {
        // 取消动画帧请求
        if (animationId) {
            cancelAnimationFrame(animationId);
            animationId = null;
        }
        
        // 清理视频资源，移除所有事件监听器
        try {
            if (video) {
                // 移除所有事件监听器
                video.onloadedmetadata = null;
                video.onprogress = null;
                video.onstalled = null;
                video.oncanplay = null;
                video.onerror = null;
                
                // 停止播放并清空资源
                video.pause();
                video.src = '';
                
                // 如果视频元素已添加到DOM中，从DOM中移除
                if (video.parentNode) {
                    video.parentNode.removeChild(video);
                } else {
                    video.remove(); // 备用移除方法
                }
                
                // 释放引用
                video = null;
                window.loveVideoElement = null;
                
                console.log('Video resources cleaned up successfully');
            }
        } catch (cleanupError) {
            console.error('Error during cleanup:', cleanupError);
            // 即使清理过程出错，也要尝试释放引用
            try {
                video = null;
                window.loveVideoElement = null;
            } catch (e) {
                console.error('Failed to nullify video reference:', e);
            }
        }
    }
    
    // 添加窗口大小变化处理
    function handleResize() {
        setDefaultBackground();
        if (video && !video.paused && video.readyState >= 2) {
            // 如果视频正在播放，重新开始绘制
            if (animationId) {
                cancelAnimationFrame(animationId);
            }
            drawVideo();
        }
    }
    
    // 存储resize处理函数的引用，方便后续移除
    window.loveVideoResizeHandler = handleResize;
    window.addEventListener('resize', handleResize);
    
    // 返回一个包含清理方法的对象，便于外部控制
    return {
        cleanup: function() {
            window.removeEventListener('resize', handleResize);
            window.loveVideoResizeHandler = null;
            cleanup();
        }
    };
}

// 暴露函数到全局作用域
window.initLoveVideoEffect = initLoveVideoEffect;